home *** CD-ROM | disk | FTP | other *** search
/ World of Video / World of Video.iso / gfxprograms / 3dprograms / rayshade-4.0 / fixes / fix023 < prev    next >
Internet Message Format  |  1995-02-13  |  15KB
  1. From theseas!Princeton.EDU!cek Tue, 28 Jun 94 16:52:03 EET
  2. Received: by kriton.UUCP (V1.16/Amiga)
  3.     id AA00000; Tue, 28 Jun 94 16:52:03 EET
  4. Received: by theseas.ntua.gr with UUCP; Tue, 28 Jun 1994 15:30:38 +0300
  5. Received: from nemesis.ics.forth.gr (nemesis.csi.forth.gr) by pythia.ics.forth.gr via FORTHnet with SMTP;
  6.     id AA25343 (5.65c/FORTH-ICS-3.0-MHS-7.0); Tue, 28 Jun 1994 14:55:29 +0300
  7. Received: from eunet.EU.net by nemesis.ics.forth.gr via FORTHnet with SMTP;
  8.     id AA10498 (5.65c/ICS-1.1); Tue, 28 Jun 1994 14:47:15 +0300 (EET DST)
  9. Received: (uunet@localhost) by eunet.EU.net (8.6.8/8.6.4) with UUCP id NAA06872 for ariadne!theseas!kriton!kyrimis; Tue, 28 Jun 1994 13:51:15 +0200
  10. Received: from Princeton.EDU by relay2.UU.NET with SMTP 
  11.     (rama) id QQwwfv14573; Tue, 28 Jun 1994 07:50:50 -0400
  12. Received: from fs.Princeton.EDU by Princeton.EDU (5.65b/2.111/princeton)
  13.     id AA04294; Tue, 28 Jun 94 07:46:16 -0400
  14. Received: by cs.Princeton.EDU (4.1/1.105)
  15.     id AA01584; Tue, 28 Jun 94 07:46:15 EDT
  16. Received: from arthur.cs.purdue.edu by cs.Princeton.EDU (4.1/1.105)
  17.     id AA01530; Tue, 28 Jun 94 07:46:01 EDT
  18. Received: from icarus.cs.purdue.edu (root@icarus.cs.purdue.edu [128.10.8.56])
  19.     by arthur.cs.purdue.edu (8.6.4/PURDUE_CS-1.3) with ESMTP
  20.     id <GAA19676> for <rayshade-users@cs.princeton.edu>; Tue, 28 Jun 1994 06:45:58 -0500
  21. Received: from localhost (bj@localhost [127.0.0.1])
  22.     by icarus.cs.purdue.edu (8.6.4/PURDUE_CS-1.3) with SMTP
  23.     id <GAA02160> for <rayshade-users@cs.princeton.edu>; Tue, 28 Jun 1994 06:45:57 -0500
  24. Organization: Institute of Computer Science, FORTH, P.O.Box 1385,
  25.      Heraklio, Crete, GR-711-10, Greece
  26.     tel.: +30 (81) 39 16 00,  fax: +30 (81) 39 16 01
  27. Message-Id: <199406281145.GAA02160@icarus.cs.purdue.edu>
  28. Date: Tue, 28 Jun 1994 06:45:57 -0500
  29. Errors-To: rayshade-users-request@cs.Princeton.EDU
  30. Remailed-Date: Tue Jun 28 07:46:03 EDT 1994
  31. From: bj@cs.purdue.edu (Ben Jackson)
  32. To: rayshade-users@cs.Princeton.EDU (Rayshade List)
  33. Subject: color raypaint under X
  34.  
  35. When I first built rayshade, I just needed it as a backend, so I didn't
  36. try to built raypaint (I assumed it needed the GL library).  Since then
  37. I've become a rayshade addict, and I built raypaint last night.  I was
  38. disappointed to discover that it would only display grayscale images,
  39. so I decided to fix it.  :-)
  40.  
  41. I figured that the original author had punted on the 8bit color code
  42. because of palette computations, so I just used a 6x6x6 standard
  43. colormap (much like xv's 24 bit mode).  At first I thought I was clever
  44. and made an adaptive algorithm that took advantage of the fact that
  45. blue and red aren't as "important" as green.  It generated 6x7x5 color
  46. maps as a first try.  It took me a LONG time to figure out what that
  47. doesn't work.
  48.  
  49. Like the grayscale code, it first tries to share the map, and backs
  50. down (5x5x5 etc down to 2x2x2) if it can't get enough colors.  If it
  51. can't get a 2x2x2 set of colors in the default map, it starts over with
  52. a private colormap.  If it fails again, it falls back on the the
  53. grayscale code (what the heck).  Everyone I know with a 24bit
  54. framebuffer also has the GL library, so I didn't worry about taking
  55. advantage of 24bit Visuals (which should probably use DirectColor
  56. anyway).
  57.  
  58. A 2x2x2 map is only 8 colors (duh), and the grayscale code insists on
  59. at least 16 colors.  2x2x2 might be too small, but I decided I'd let
  60. you guys decide if 3x3x3 or higher would be a more reasonable limit.
  61.  
  62. Since grayscale is useful on 8bit displays (giving more detail in some
  63. cases than a 6x6x6 colormap), I decided to add an option to force the
  64. gray map.  This wasn't as straightforward as I'd hoped, since raypaint
  65. uses the same option parser as rayshade, which doesn't need this option
  66. (and even if it did, you might want to watch the rendering in grayscale
  67. while still generating 24bit color output).  I added a small check for
  68. '-M' in raypaint/main.c.  If it sees it, it sets the flag and removes
  69. it from the options list.  This is a hack, but I don't see a better way
  70. to do it without also adding the option to rayshade.
  71.  
  72. While I was in the code, I fixed a bug in the Rectangle rendering
  73. code.  It was approximating the color of the whole rectangle as the
  74. color of the lower left corner.  I added the code to average the four
  75. color values, which makes the scene look a bit more realistic while
  76. it's still blocky (which makes it easier to find the regions you want
  77. to refine).  I did manage to resist the temptation to run the whole file
  78. through GNU Indent, since that would make the diff's unreasonable.
  79.  
  80. Once again, I'm not on the rayshade-users list, so please reply to (or
  81. at least Cc) me.  Comments welcome.
  82.  
  83. --Ben
  84.  
  85. *** raypaint/main.c.orig    Tue Jun 28 05:19:44 1994
  86. --- raypaint/main.c    Tue Jun 28 05:48:15 1994
  87. ***************
  88. *** 31,36 ****
  89. --- 31,37 ----
  90.   #include "picture.h"
  91.   
  92.   void RSInitialize(), RSStartFrame();
  93. + int gray;
  94.   
  95.   int
  96.   main(argc, argv)
  97. ***************
  98. *** 65,71 ****
  99.       /*
  100.        * Render the image.
  101.        */
  102. !     Render(argc, argv);
  103.       StatsPrint();
  104.       return 0;
  105.   }
  106. --- 66,72 ----
  107.       /*
  108.        * Render the image.
  109.        */
  110. !     Render(argc, argv, gray);
  111.       StatsPrint();
  112.       return 0;
  113.   }
  114. ***************
  115. *** 100,109 ****
  116. --- 101,126 ----
  117.   int argc;
  118.   char **argv;
  119.   {
  120. +     int i;
  121. + 
  122.       /*
  123.         * Initialize variables, etc.
  124.        */
  125.       RSSetup();
  126. +     /*
  127. +      * Steal the gray option, -M (mono, OK?)
  128. +      */
  129. +     gray = 0;
  130. +     for (i = 1; i < argc; ++i) {
  131. +         if ('-' != argv[i][0] || 'M' != argv[i][1]) {
  132. +             continue;
  133. +         }
  134. +         gray = 1;
  135. +         for (; i < argc; ++i) {
  136. +             argv[i] = argv[i+1];
  137. +         }
  138. +         --argc;
  139. +     }
  140.       /*
  141.        * Parse options from command line.
  142.        */
  143. *** raypaint/render.c.orig    Tue Jun 28 05:44:07 1994
  144. --- raypaint/render.c    Tue Jun 28 05:46:07 1994
  145. ***************
  146. *** 122,130 ****
  147.   int    SuperSampleMode = 0;
  148.   #define SSCLOSED (SuperSampleMode + 1)
  149.   
  150. ! Render(argc, argv)
  151.   int argc;
  152.   char **argv;
  153.   {
  154.       /*
  155.        * Do an adaptive trace, displaying results in a
  156. --- 122,131 ----
  157.   int    SuperSampleMode = 0;
  158.   #define SSCLOSED (SuperSampleMode + 1)
  159.   
  160. ! Render(argc, argv, gray)
  161.   int argc;
  162.   char **argv;
  163. + int gray;
  164.   {
  165.       /*
  166.        * Do an adaptive trace, displaying results in a
  167. ***************
  168. *** 148,154 ****
  169.        */
  170.       TopRay.time = Options.framestart;
  171.   
  172. !     GraphicsInit(Screen.xsize, Screen.ysize, "rayview");
  173.       /*
  174.        * Allocate array of samples.
  175.        */
  176. --- 149,155 ----
  177.        */
  178.       TopRay.time = Options.framestart;
  179.   
  180. !     GraphicsInit(Screen.xsize, Screen.ysize, "rayview", gray);
  181.       /*
  182.        * Allocate array of samples.
  183.        */
  184. *** raypaint/xgraphics.c.orig    Sun Feb  9 22:03:51 1992
  185. --- raypaint/xgraphics.c    Tue Jun 28 05:45:59 1994
  186. ***************
  187. *** 33,40 ****
  188.   GC gc;
  189.   Window win;
  190.   int screen_height;
  191.   
  192. ! unsigned long graymap[256];
  193.   int max_colors;
  194.   double one_over_gamma = 0.4;
  195.   
  196. --- 33,41 ----
  197.   GC gc;
  198.   Window win;
  199.   int screen_height;
  200. + int gray;
  201.   
  202. ! unsigned long colormap[256];
  203.   int max_colors;
  204.   double one_over_gamma = 0.4;
  205.   
  206. ***************
  207. *** 42,47 ****
  208. --- 43,49 ----
  209.    * Sets the gray color map for the device.  A 2.5 gamma map is used
  210.    * by default.
  211.    */
  212. + static
  213.   setup_gray_gamma_map()
  214.   {
  215.       int cc, col;
  216. ***************
  217. *** 49,54 ****
  218. --- 51,57 ----
  219.   
  220.       XColor xcolor;
  221.   
  222. +     gray = 1;
  223.       /* Use the default colormap if possible. */
  224.       if ( vis == DefaultVisualOfScreen( scrn ) )
  225.           cmap = DefaultColormapOfScreen( scrn );
  226. ***************
  227. *** 67,77 ****
  228.               xcolor.blue= gamma_color;
  229.               if (!XAllocColor(dpy, cmap, &xcolor)) {
  230.                   for (cc=0; cc < col; cc++)
  231. !                     XFreeColors(dpy, cmap, &graymap[cc], 1, 0);
  232.                   col = 0;
  233.                   break;
  234.               }
  235. !             graymap[col] = xcolor.pixel;
  236.           }
  237.           if (col)
  238.               return;
  239. --- 70,80 ----
  240.               xcolor.blue= gamma_color;
  241.               if (!XAllocColor(dpy, cmap, &xcolor)) {
  242.                   for (cc=0; cc < col; cc++)
  243. !                     XFreeColors(dpy, cmap, &colormap[cc], 1, 0);
  244.                   col = 0;
  245.                   break;
  246.               }
  247. !             colormap[col] = xcolor.pixel;
  248.           }
  249.           if (col)
  250.               return;
  251. ***************
  252. *** 85,97 ****
  253.           exit(-2);
  254.       }
  255.       for(cc=0; cc < 256; cc++)
  256. !         if (!XAllocColorCells(dpy, cmap, False, NULL, 0, &graymap[cc], 1))
  257.               break;
  258.       max_colors = cc;
  259.   
  260.       xcolor.flags= DoRed | DoGreen | DoBlue;
  261.       for(col=0; col < max_colors; col++) {
  262. !         xcolor.pixel= graymap[col];
  263.           gamma_color = (pow((float) col / (float) max_colors,
  264.                              one_over_gamma) * 65536);
  265.           xcolor.red= gamma_color;
  266. --- 88,100 ----
  267.           exit(-2);
  268.       }
  269.       for(cc=0; cc < 256; cc++)
  270. !         if (!XAllocColorCells(dpy, cmap, False, NULL, 0, &colormap[cc], 1))
  271.               break;
  272.       max_colors = cc;
  273.   
  274.       xcolor.flags= DoRed | DoGreen | DoBlue;
  275.       for(col=0; col < max_colors; col++) {
  276. !         xcolor.pixel= colormap[col];
  277.           gamma_color = (pow((float) col / (float) max_colors,
  278.                              one_over_gamma) * 65536);
  279.           xcolor.red= gamma_color;
  280. ***************
  281. *** 101,109 ****
  282.       }
  283.   }
  284.   
  285. ! GraphicsInit(xsize, ysize, name)
  286.   int xsize, ysize;
  287.   char *name;
  288.   {
  289.       int win_size;
  290.       XSetWindowAttributes attrs;
  291. --- 104,181 ----
  292.       }
  293.   }
  294.   
  295. ! /*****************************************************************
  296. !  * Sets the color map for the device.  A 2.5 gamma map is used
  297. !  * by default, with a direct 6x7x5 colormap
  298. !  */
  299. ! static
  300. ! setup_color_gamma_map()
  301. ! {
  302. !     static int first_try = 1;
  303. !     int cc, col;
  304. !     int r, g, b;
  305. !     int done;
  306. ! 
  307. !     XColor xcolor;
  308. ! 
  309. !     /* Use the default colormap if possible. */
  310. !     if (first_try && vis == DefaultVisualOfScreen(scrn)) {
  311. !         cmap = DefaultColormapOfScreen(scrn);
  312. !     } else {
  313. !         cmap = XCreateColormap(dpy, RootWindowOfScreen(scrn),
  314. !                                vis, AllocNone );
  315. !     }
  316. ! 
  317. !     /* try to share with current colormap */
  318. !     xcolor.flags= DoRed | DoGreen | DoBlue;
  319. !     for (max_colors = 6; max_colors >= 2; --max_colors) {
  320. !     done = 1; /* gets unset on failure */
  321. !     col = 0;
  322. !     for (r = 0; r < max_colors; ++r) {
  323. !         xcolor.red = pow((float) r / (float) max_colors,
  324. !         one_over_gamma) * 65536;
  325. !         for (g = 0; g < max_colors; ++g) {
  326. !         xcolor.green = pow((float) g / (float) max_colors,
  327. !             one_over_gamma) * 65536;
  328. !         for (b = 0; b < max_colors; ++b) {
  329. !             xcolor.blue = pow((float) b / (float) max_colors,
  330. !                     one_over_gamma) * 65536;
  331. !             if (!XAllocColor(dpy, cmap, &xcolor)) {
  332. !             for (cc=0; cc < col; cc++)
  333. !                 XFreeColors(dpy, cmap, &colormap[cc], 1, 0);
  334. !             r = g = b = 99;
  335. !                 done = 0;
  336. !                 break;
  337. !             }
  338. !             colormap[col++] = xcolor.pixel;
  339. !         }
  340. !         }
  341. !     }
  342. !     if (done)
  343. !         break;
  344. !     }
  345. !     if (!done) {
  346. !     if (first_try) {
  347. !         /* go back and try with a private color map */
  348. !         first_try = 0;
  349. !         setup_color_gamma_map();
  350. !     }
  351. !     /* our smallest color set (2x2x2 = 8) is smaller than the
  352. !      * grayscale code (16), but we still try the gray map because
  353. !      * it might be able to share colors.
  354. !      */
  355. !         fprintf(stderr, "Could not create color map -- trying grayscale\n");
  356. !     setup_gray_gamma_map();
  357. !     return;
  358. !     }
  359. !     fprintf(stderr, "using standard %dx%dx%d colormap\n", max_colors, max_colors, max_colors);
  360. !     gray = 0;
  361. ! }
  362. ! 
  363. ! GraphicsInit(xsize, ysize, name, gray)
  364.   int xsize, ysize;
  365.   char *name;
  366. + int gray;
  367.   {
  368.       int win_size;
  369.       XSetWindowAttributes attrs;
  370. ***************
  371. *** 143,149 ****
  372.           scrn = ScreenOfDisplay( dpy, max_vis->screen );
  373.           gc = DefaultGCOfScreen( scrn );
  374.   
  375. !         setup_gray_gamma_map();
  376.   
  377.           XFree( (char *)vis_list );
  378.       }
  379. --- 215,225 ----
  380.           scrn = ScreenOfDisplay( dpy, max_vis->screen );
  381.           gc = DefaultGCOfScreen( scrn );
  382.   
  383. !     if (gray) {
  384. !         setup_gray_gamma_map();
  385. !     } else {
  386. !             setup_color_gamma_map();
  387. !     }
  388.   
  389.           XFree( (char *)vis_list );
  390.       }
  391. ***************
  392. *** 181,192 ****
  393.   int xp, yp;
  394.   unsigned char color[3];
  395.   {
  396. -     float bwvalue;
  397.       int val;
  398.   
  399. !     bwvalue = ( 0.35*color[0] + 0.55*color[1] + 0.10*color[2] ) / 256.0;
  400. !     val = (int) ( bwvalue * max_colors );
  401. !     XSetForeground( dpy, gc, graymap[val] );
  402.       XFillRectangle( dpy, win, gc, xp, (screen_height - (yp + 1)),
  403.                       1, 1 );
  404.   }
  405. --- 257,274 ----
  406.   int xp, yp;
  407.   unsigned char color[3];
  408.   {
  409.       int val;
  410.   
  411. !     if (gray) {
  412. !     val = (0.35*color[0] + 0.55*color[1] + 0.10*color[2]) / 256.0 * max_colors;
  413. !     } else {
  414. !     val = color[0] / 256.0 * max_colors;
  415. !     val *= max_colors;
  416. !     val += color[1] / 256.0 * max_colors;
  417. !     val *= max_colors;
  418. !     val += color[2] / 256.0 * max_colors;
  419. !     }
  420. !     XSetForeground( dpy, gc, colormap[val] );
  421.       XFillRectangle( dpy, win, gc, xp, (screen_height - (yp + 1)),
  422.                       1, 1 );
  423.   }
  424. ***************
  425. *** 200,211 ****
  426.   int xp, yp, xs, ys;
  427.   unsigned char ll[3], lr[3], ur[3], ul[3];
  428.   {
  429. -     float bwvalue;
  430.       int val;
  431.   
  432. !     bwvalue = ( 0.35*ll[0] + 0.55*ll[1] + 0.10*ll[2] ) / 256.0;
  433. !     val = (int) ( bwvalue * max_colors );
  434. !     XSetForeground( dpy, gc, graymap[val] );
  435.       XFillRectangle( dpy, win, gc, xp, (screen_height - (yp + ys + 1)),
  436.                       xs+1, ys+1 );
  437.       XFlush( dpy );
  438. --- 282,302 ----
  439.   int xp, yp, xs, ys;
  440.   unsigned char ll[3], lr[3], ur[3], ul[3];
  441.   {
  442.       int val;
  443.   
  444. !     ll[0] = (ll[0] + lr[0] + ur[0] + ul[0]) / 4;
  445. !     ll[1] = (ll[1] + lr[1] + ur[1] + ul[1]) / 4;
  446. !     ll[2] = (ll[2] + lr[2] + ur[2] + ul[2]) / 4;
  447. !     if (gray) {
  448. !     val = (0.35*ll[0] + 0.55*ll[1] + 0.10*ll[2]) / 256.0 * max_colors;
  449. !     } else {
  450. !     val = ll[0] / 256.0 * max_colors;
  451. !     val *= max_colors;
  452. !     val += ll[1] / 256.0 * max_colors;
  453. !     val *= max_colors;
  454. !     val += ll[2] / 256.0 * max_colors;
  455. !     }
  456. !     XSetForeground( dpy, gc, colormap[val] );
  457.       XFillRectangle( dpy, win, gc, xp, (screen_height - (yp + ys + 1)),
  458.                       xs+1, ys+1 );
  459.       XFlush( dpy );
  460. ***************
  461. *** 275,281 ****
  462.   {
  463.           XEvent event;
  464.           if (XCheckTypedEvent(dpy, Expose, &event)) {
  465. !                 XSetForeground( dpy, gc, graymap[0] );
  466.                   XFillRectangle( dpy, win, gc, event.xexpose.x, event.xexpose.y,
  467.                       event.xexpose.width, event.xexpose.height );
  468.                   XFlush( dpy );
  469. --- 366,372 ----
  470.   {
  471.           XEvent event;
  472.           if (XCheckTypedEvent(dpy, Expose, &event)) {
  473. !                 XSetForeground( dpy, gc, colormap[0] );
  474.                   XFillRectangle( dpy, win, gc, event.xexpose.x, event.xexpose.y,
  475.                       event.xexpose.width, event.xexpose.height );
  476.                   XFlush( dpy );
  477.  
  478. ----------
  479. Administrivia: rayshade-users-request@cs.princeton.edu
  480. Mailing list: rayshade-users@cs.princeton.edu
  481.  
  482.